package android.slc.commonlibrary.util.compat;

import android.slc.hutool.compat.core.text.StrJoinerCompat;

import androidx.annotation.Nullable;

import com.blankj.utilcode.util.ObjectUtils;
import com.blankj.utilcode.util.StringUtils;

import java.util.Arrays;
import java.util.List;

import cn.hutool.core.collection.IterUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.StrUtil;


/**
 * @Description:
 * @Author: sunlunchang
 * @CreateDate: 2022/04/06 下午 5:06
 */
public class SlcJoinUtils {

    public static int toInt(final Object str) {
        return SlcNumberUtils.toInt(String.valueOf(str));
    }

    public static int toInt(@Nullable final Object str, final int defaultValue) {
        return SlcNumberUtils.toInt(String.valueOf(str), defaultValue);
    }

    public static long toLong(final Object str) {
        return SlcNumberUtils.toLong(String.valueOf(str));
    }

    public static long toLong(@Nullable final Object str, final long defaultValue) {
        return SlcNumberUtils.toLong(String.valueOf(str), defaultValue);
    }

    public static Double toDouble(Object value) {
        return toDouble(String.valueOf(value), -1.0D);
    }

    public static Double toDouble(Object value, Double defaultValue) {
        return SlcNumberUtils.toDouble(String.valueOf(value), defaultValue);
    }

    public static Float toFloat(Object value) {
        return toFloat(String.valueOf(value), -1.0F);
    }

    public static Float toFloat(Object value, Float defaultValue) {
        return SlcNumberUtils.toFloat(String.valueOf(value), defaultValue);
    }

    public static Boolean toBoolean(Object value) {
        return toBoolean(value, (Boolean) null);
    }

    public static Boolean toBoolean(Object value, Boolean defaultValue) {
        if (value != null) {
            String val = String.valueOf(value);
            val = val.toLowerCase().trim();
            return Boolean.parseBoolean(val);
        } else {
            return defaultValue;
        }
    }

    public static Integer[] toIntArray(String str) {
        return toIntArray(",", str);
    }

    public static Integer[] toIntArray(String split, String str) {
        if (StringUtils.isEmpty(str)) {
            return new Integer[0];
        } else {
            String[] arr = str.split(split);
            Integer[] ints = new Integer[arr.length];

            for (int i = 0; i < arr.length; ++i) {
                Integer v = toInt(arr[i], 0);
                ints[i] = v;
            }

            return ints;
        }
    }

    public static List<Integer> toIntList(String str) {
        return Arrays.asList(toIntArray(str));
    }

    public static List<Integer> toIntList(String split, String str) {
        return Arrays.asList(toIntArray(split, str));
    }

    public static Integer firstInt(String str) {
        return firstInt(",", str);
    }

    public static Integer firstInt(String split, String str) {
        List<Integer> ints = toIntList(split, str);
        return ObjectUtils.isEmpty(ints) ? null : (Integer) ints.get(0);
    }

    public static Long[] toLongArray(String str) {
        return toLongArray(",", str);
    }

    public static Long[] toLongArray(String split, String str) {
        if (StringUtils.isEmpty(str)) {
            return new Long[0];
        } else {
            String[] arr = str.split(split);
            Long[] longs = new Long[arr.length];

            for (int i = 0; i < arr.length; ++i) {
                Long v = toLong(arr[i], 0L);
                longs[i] = v;
            }

            return longs;
        }
    }

    public static List<Long> toLongList(String str) {
        return Arrays.asList(toLongArray(str));
    }

    public static List<Long> toLongList(String split, String str) {
        return Arrays.asList(toLongArray(split, str));
    }

    public static Long firstLong(String str) {
        return firstLong(",", str);
    }

    public static Long firstLong(String split, String str) {
        List<Long> longs = toLongList(split, str);
        return ObjectUtils.isEmpty((Object) longs) ? null : (Long) longs.get(0);
    }

    public static String[] toStrArray(String str) {
        return toStrArray(",", str);
    }

    public static String[] toStrArray(String split, String str) {
        return StrUtil.isBlank(str) ? new String[0] : str.split(split);
    }

    public static List<String> toStrList(String str) {
        return Arrays.asList(toStrArray(str));
    }

    public static List<String> toStrList(String split, String str) {
        return Arrays.asList(toStrArray(split, str));
    }

    public static String firstStr(String str) {
        return firstStr(",", str);
    }

    public static String firstStr(String split, String str) {
        List<String> strs = toStrList(split, str);
        return ObjectUtils.isEmpty((Object) strs) ? null : (String) strs.get(0);
    }

    public static String to62String(long num) {
        return SlcNumberUtils.to62String(num);
    }


    /**
     * 以 conjunction 为分隔符将数组转换为字符串
     *
     * @param <T>         被处理的集合
     * @param array       数组
     * @param conjunction 分隔符
     * @return 连接后的字符串
     */
    public static <T> String join(T[] array, CharSequence conjunction) {
        return join(array, conjunction, null, null);
    }

    /**
     * 以 conjunction 为分隔符将数组转换为字符串
     *
     * @param <T>       被处理的集合
     * @param array     数组
     * @param delimiter 分隔符
     * @param prefix    每个元素添加的前缀，null表示不添加
     * @param suffix    每个元素添加的后缀，null表示不添加
     * @return 连接后的字符串
     * @since 4.0.10
     */
    public static <T> String join(T[] array, CharSequence delimiter, String prefix, String suffix) {
        return ArrayUtil.join(array, delimiter, prefix, suffix);
    }

    /**
     * 以 conjunction 为分隔符将数组转换为字符串
     *
     * @param <T>         被处理的集合
     * @param array       数组
     * @param conjunction 分隔符
     * @param transition  每个元素的编辑器，null表示不编辑
     * @return 连接后的字符串
     * @since 5.3.3
     */
    public static <T, T2> String join(T[] array, CharSequence conjunction, Transition<T, T2> transition) {
        return StrJoinerCompat.of(conjunction).append(array, (t) -> String.valueOf(transition.toT2(t))).toString();
    }

    /**
     * 以 conjunction 为分隔符将数组转换为字符串
     *
     * @param array       数组
     * @param conjunction 分隔符
     * @return 连接后的字符串
     */
    public static String join(Object array, CharSequence conjunction) {
        return ArrayUtil.join(array, conjunction);
    }


    /**
     * 以 conjunction 为分隔符将数组转换为字符串
     *
     * @param <T>         被处理的集合
     * @param list        列表
     * @param conjunction 分隔符
     * @return 连接后的字符串
     */
    public static <T> String join(List<T> list, CharSequence conjunction) {
        return join(list, conjunction, null, null);
    }

    /**
     * 以 conjunction 为分隔符将数组转换为字符串
     *
     * @param <T>       被处理的集合
     * @param list      列表
     * @param delimiter 分隔符
     * @param prefix    每个元素添加的前缀，null表示不添加
     * @param suffix    每个元素添加的后缀，null表示不添加
     * @return 连接后的字符串
     * @since 4.0.10
     */
    public static <T> String join(List<T> list, CharSequence delimiter, String prefix, String suffix) {
        return IterUtil.join(list, delimiter, prefix, suffix);
    }

    /**
     * 以 conjunction 为分隔符将数组转换为字符串
     *
     * @param <T>         被处理的集合
     * @param list        列表
     * @param conjunction 分隔符
     * @param transition  每个元素的编辑器，null表示不编辑
     * @return 连接后的字符串
     * @since 5.3.3
     */
    public static <T, T2> String join(List<T> list, CharSequence conjunction, Transition<T, T2> transition) {
        return StrJoinerCompat.of(conjunction).append(list, (t) -> String.valueOf(transition.toT2(t))).toString();
    }

    public interface Transition<T1, T2> {
        T2 toT2(T1 t1);
    }
}
